* gtk-boxed.defs: s/GkWidget/GtkWidget/
+Wed Jun 24 07:47:29 1998 Tim Janik <timj@gtk.org>
+
+ * gtk/testgtk.c (create_idle_test): added a frame with radio buttons
+ to select the resize_mode for the idle-labels container.
+
+ * gtk/gtkframe.h:
+ * gtk/gtkframe.c: GtkType and macro corrections.
+
+ * gtk/gtkradiobutton.c (gtk_radio_button_set_arg): new function to
+ support radio grouping.
+
+Tue Jun 23 08:01:09 1998 Tim Janik <timj@gtk.org>
+
+ * gtk/gtkcontainer.c (gtk_container_set_resize_mode): queue a resize
+ unconditionally if resize_mode has changed.
+
+ * gtk/gtkscrolledwindow.c (gtk_scrolled_window_init): set
+ GTK_RESIZE_QUEUE on the scrolled window.
+ (gtk_scrolled_window_construct): set GTK_RESIZE_PARENT for the vieport.
+
+Tue Jun 23 04:20:30 1998 Tim Janik <timj@gtk.org>
+
+ * gtk/gtkcontainer.h:
+ * gtk/gtkcontainer.c:
+ (GTK_IS_RESIZE_CONTAINER): new macro to find out if
+ a given gtkobject is a container with resize_mode==GTK_RESIZE_PARENT.
+ (gtk_container_queue_resize): new function to queue a container for
+ a *size* reallocation (doesn't affect its position, and thus its
+ parent is left untouched usually).
+ (gtk_container_get_resize_container): new function to retrive the next
+ most resize container which is not itself queued for a resize.
+ (gtk_container_idle_sizer): new function to carefully process the
+ container_resize_queue since it can change during invokation of
+ gtk_container_check_resize().
+ (gtk_container_resize_children): total rework of this function to
+ properly handle resize containers. makes a lot of assumptions whitch
+ are stated in the comments.
+
+ * gtk/gtkcontainer.c:
+ (gtk_container_real_check_resize): only requeue ourselves if we are not
+ a resize container.
+ (gtk_container_clear_resize_widgets): care for automatic deletion of our
+ resize_widgets list on size_allocate through a handler connection.
+
+ * gtk/gtkwindow.c (gtk_window_shutdown): new functionm to reset the
+ focus and default widget of a window, so to take the burden from
+ gtk_widget_unparent.
+
+ * gtk/gtkviewport.c: removed gtk_viewport_check_resize, which tried
+ to be clever, but actually messed up the resize_children logic and
+ caused unneccessary allocations on its whole branch. besides this,
+ it messed up the display by not invoking a redraw after the allocation.
+
+ * gtk/gtktable.c (gtk_table_set_child_arg): reverted recent change, so
+ that it is the child again that is queued for a resize.
+ (gtk_table_attach): likewise.
+ (gtk_table_remove): likewise.
+
1998-06-22 Miguel de Icaza <miguel@nuclecu.unam.mx>
* gtk/gtkentry.h, gtk/gtkentry.c: Export the
* gtk-boxed.defs: s/GkWidget/GtkWidget/
+Wed Jun 24 07:47:29 1998 Tim Janik <timj@gtk.org>
+
+ * gtk/testgtk.c (create_idle_test): added a frame with radio buttons
+ to select the resize_mode for the idle-labels container.
+
+ * gtk/gtkframe.h:
+ * gtk/gtkframe.c: GtkType and macro corrections.
+
+ * gtk/gtkradiobutton.c (gtk_radio_button_set_arg): new function to
+ support radio grouping.
+
+Tue Jun 23 08:01:09 1998 Tim Janik <timj@gtk.org>
+
+ * gtk/gtkcontainer.c (gtk_container_set_resize_mode): queue a resize
+ unconditionally if resize_mode has changed.
+
+ * gtk/gtkscrolledwindow.c (gtk_scrolled_window_init): set
+ GTK_RESIZE_QUEUE on the scrolled window.
+ (gtk_scrolled_window_construct): set GTK_RESIZE_PARENT for the vieport.
+
+Tue Jun 23 04:20:30 1998 Tim Janik <timj@gtk.org>
+
+ * gtk/gtkcontainer.h:
+ * gtk/gtkcontainer.c:
+ (GTK_IS_RESIZE_CONTAINER): new macro to find out if
+ a given gtkobject is a container with resize_mode==GTK_RESIZE_PARENT.
+ (gtk_container_queue_resize): new function to queue a container for
+ a *size* reallocation (doesn't affect its position, and thus its
+ parent is left untouched usually).
+ (gtk_container_get_resize_container): new function to retrive the next
+ most resize container which is not itself queued for a resize.
+ (gtk_container_idle_sizer): new function to carefully process the
+ container_resize_queue since it can change during invokation of
+ gtk_container_check_resize().
+ (gtk_container_resize_children): total rework of this function to
+ properly handle resize containers. makes a lot of assumptions whitch
+ are stated in the comments.
+
+ * gtk/gtkcontainer.c:
+ (gtk_container_real_check_resize): only requeue ourselves if we are not
+ a resize container.
+ (gtk_container_clear_resize_widgets): care for automatic deletion of our
+ resize_widgets list on size_allocate through a handler connection.
+
+ * gtk/gtkwindow.c (gtk_window_shutdown): new functionm to reset the
+ focus and default widget of a window, so to take the burden from
+ gtk_widget_unparent.
+
+ * gtk/gtkviewport.c: removed gtk_viewport_check_resize, which tried
+ to be clever, but actually messed up the resize_children logic and
+ caused unneccessary allocations on its whole branch. besides this,
+ it messed up the display by not invoking a redraw after the allocation.
+
+ * gtk/gtktable.c (gtk_table_set_child_arg): reverted recent change, so
+ that it is the child again that is queued for a resize.
+ (gtk_table_attach): likewise.
+ (gtk_table_remove): likewise.
+
1998-06-22 Miguel de Icaza <miguel@nuclecu.unam.mx>
* gtk/gtkentry.h, gtk/gtkentry.c: Export the
* gtk-boxed.defs: s/GkWidget/GtkWidget/
+Wed Jun 24 07:47:29 1998 Tim Janik <timj@gtk.org>
+
+ * gtk/testgtk.c (create_idle_test): added a frame with radio buttons
+ to select the resize_mode for the idle-labels container.
+
+ * gtk/gtkframe.h:
+ * gtk/gtkframe.c: GtkType and macro corrections.
+
+ * gtk/gtkradiobutton.c (gtk_radio_button_set_arg): new function to
+ support radio grouping.
+
+Tue Jun 23 08:01:09 1998 Tim Janik <timj@gtk.org>
+
+ * gtk/gtkcontainer.c (gtk_container_set_resize_mode): queue a resize
+ unconditionally if resize_mode has changed.
+
+ * gtk/gtkscrolledwindow.c (gtk_scrolled_window_init): set
+ GTK_RESIZE_QUEUE on the scrolled window.
+ (gtk_scrolled_window_construct): set GTK_RESIZE_PARENT for the vieport.
+
+Tue Jun 23 04:20:30 1998 Tim Janik <timj@gtk.org>
+
+ * gtk/gtkcontainer.h:
+ * gtk/gtkcontainer.c:
+ (GTK_IS_RESIZE_CONTAINER): new macro to find out if
+ a given gtkobject is a container with resize_mode==GTK_RESIZE_PARENT.
+ (gtk_container_queue_resize): new function to queue a container for
+ a *size* reallocation (doesn't affect its position, and thus its
+ parent is left untouched usually).
+ (gtk_container_get_resize_container): new function to retrive the next
+ most resize container which is not itself queued for a resize.
+ (gtk_container_idle_sizer): new function to carefully process the
+ container_resize_queue since it can change during invokation of
+ gtk_container_check_resize().
+ (gtk_container_resize_children): total rework of this function to
+ properly handle resize containers. makes a lot of assumptions whitch
+ are stated in the comments.
+
+ * gtk/gtkcontainer.c:
+ (gtk_container_real_check_resize): only requeue ourselves if we are not
+ a resize container.
+ (gtk_container_clear_resize_widgets): care for automatic deletion of our
+ resize_widgets list on size_allocate through a handler connection.
+
+ * gtk/gtkwindow.c (gtk_window_shutdown): new functionm to reset the
+ focus and default widget of a window, so to take the burden from
+ gtk_widget_unparent.
+
+ * gtk/gtkviewport.c: removed gtk_viewport_check_resize, which tried
+ to be clever, but actually messed up the resize_children logic and
+ caused unneccessary allocations on its whole branch. besides this,
+ it messed up the display by not invoking a redraw after the allocation.
+
+ * gtk/gtktable.c (gtk_table_set_child_arg): reverted recent change, so
+ that it is the child again that is queued for a resize.
+ (gtk_table_attach): likewise.
+ (gtk_table_remove): likewise.
+
1998-06-22 Miguel de Icaza <miguel@nuclecu.unam.mx>
* gtk/gtkentry.h, gtk/gtkentry.c: Export the
* gtk-boxed.defs: s/GkWidget/GtkWidget/
+Wed Jun 24 07:47:29 1998 Tim Janik <timj@gtk.org>
+
+ * gtk/testgtk.c (create_idle_test): added a frame with radio buttons
+ to select the resize_mode for the idle-labels container.
+
+ * gtk/gtkframe.h:
+ * gtk/gtkframe.c: GtkType and macro corrections.
+
+ * gtk/gtkradiobutton.c (gtk_radio_button_set_arg): new function to
+ support radio grouping.
+
+Tue Jun 23 08:01:09 1998 Tim Janik <timj@gtk.org>
+
+ * gtk/gtkcontainer.c (gtk_container_set_resize_mode): queue a resize
+ unconditionally if resize_mode has changed.
+
+ * gtk/gtkscrolledwindow.c (gtk_scrolled_window_init): set
+ GTK_RESIZE_QUEUE on the scrolled window.
+ (gtk_scrolled_window_construct): set GTK_RESIZE_PARENT for the vieport.
+
+Tue Jun 23 04:20:30 1998 Tim Janik <timj@gtk.org>
+
+ * gtk/gtkcontainer.h:
+ * gtk/gtkcontainer.c:
+ (GTK_IS_RESIZE_CONTAINER): new macro to find out if
+ a given gtkobject is a container with resize_mode==GTK_RESIZE_PARENT.
+ (gtk_container_queue_resize): new function to queue a container for
+ a *size* reallocation (doesn't affect its position, and thus its
+ parent is left untouched usually).
+ (gtk_container_get_resize_container): new function to retrive the next
+ most resize container which is not itself queued for a resize.
+ (gtk_container_idle_sizer): new function to carefully process the
+ container_resize_queue since it can change during invokation of
+ gtk_container_check_resize().
+ (gtk_container_resize_children): total rework of this function to
+ properly handle resize containers. makes a lot of assumptions whitch
+ are stated in the comments.
+
+ * gtk/gtkcontainer.c:
+ (gtk_container_real_check_resize): only requeue ourselves if we are not
+ a resize container.
+ (gtk_container_clear_resize_widgets): care for automatic deletion of our
+ resize_widgets list on size_allocate through a handler connection.
+
+ * gtk/gtkwindow.c (gtk_window_shutdown): new functionm to reset the
+ focus and default widget of a window, so to take the burden from
+ gtk_widget_unparent.
+
+ * gtk/gtkviewport.c: removed gtk_viewport_check_resize, which tried
+ to be clever, but actually messed up the resize_children logic and
+ caused unneccessary allocations on its whole branch. besides this,
+ it messed up the display by not invoking a redraw after the allocation.
+
+ * gtk/gtktable.c (gtk_table_set_child_arg): reverted recent change, so
+ that it is the child again that is queued for a resize.
+ (gtk_table_attach): likewise.
+ (gtk_table_remove): likewise.
+
1998-06-22 Miguel de Icaza <miguel@nuclecu.unam.mx>
* gtk/gtkentry.h, gtk/gtkentry.c: Export the
* gtk-boxed.defs: s/GkWidget/GtkWidget/
+Wed Jun 24 07:47:29 1998 Tim Janik <timj@gtk.org>
+
+ * gtk/testgtk.c (create_idle_test): added a frame with radio buttons
+ to select the resize_mode for the idle-labels container.
+
+ * gtk/gtkframe.h:
+ * gtk/gtkframe.c: GtkType and macro corrections.
+
+ * gtk/gtkradiobutton.c (gtk_radio_button_set_arg): new function to
+ support radio grouping.
+
+Tue Jun 23 08:01:09 1998 Tim Janik <timj@gtk.org>
+
+ * gtk/gtkcontainer.c (gtk_container_set_resize_mode): queue a resize
+ unconditionally if resize_mode has changed.
+
+ * gtk/gtkscrolledwindow.c (gtk_scrolled_window_init): set
+ GTK_RESIZE_QUEUE on the scrolled window.
+ (gtk_scrolled_window_construct): set GTK_RESIZE_PARENT for the vieport.
+
+Tue Jun 23 04:20:30 1998 Tim Janik <timj@gtk.org>
+
+ * gtk/gtkcontainer.h:
+ * gtk/gtkcontainer.c:
+ (GTK_IS_RESIZE_CONTAINER): new macro to find out if
+ a given gtkobject is a container with resize_mode==GTK_RESIZE_PARENT.
+ (gtk_container_queue_resize): new function to queue a container for
+ a *size* reallocation (doesn't affect its position, and thus its
+ parent is left untouched usually).
+ (gtk_container_get_resize_container): new function to retrive the next
+ most resize container which is not itself queued for a resize.
+ (gtk_container_idle_sizer): new function to carefully process the
+ container_resize_queue since it can change during invokation of
+ gtk_container_check_resize().
+ (gtk_container_resize_children): total rework of this function to
+ properly handle resize containers. makes a lot of assumptions whitch
+ are stated in the comments.
+
+ * gtk/gtkcontainer.c:
+ (gtk_container_real_check_resize): only requeue ourselves if we are not
+ a resize container.
+ (gtk_container_clear_resize_widgets): care for automatic deletion of our
+ resize_widgets list on size_allocate through a handler connection.
+
+ * gtk/gtkwindow.c (gtk_window_shutdown): new functionm to reset the
+ focus and default widget of a window, so to take the burden from
+ gtk_widget_unparent.
+
+ * gtk/gtkviewport.c: removed gtk_viewport_check_resize, which tried
+ to be clever, but actually messed up the resize_children logic and
+ caused unneccessary allocations on its whole branch. besides this,
+ it messed up the display by not invoking a redraw after the allocation.
+
+ * gtk/gtktable.c (gtk_table_set_child_arg): reverted recent change, so
+ that it is the child again that is queued for a resize.
+ (gtk_table_attach): likewise.
+ (gtk_table_remove): likewise.
+
1998-06-22 Miguel de Icaza <miguel@nuclecu.unam.mx>
* gtk/gtkentry.h, gtk/gtkentry.c: Export the
* gtk-boxed.defs: s/GkWidget/GtkWidget/
+Wed Jun 24 07:47:29 1998 Tim Janik <timj@gtk.org>
+
+ * gtk/testgtk.c (create_idle_test): added a frame with radio buttons
+ to select the resize_mode for the idle-labels container.
+
+ * gtk/gtkframe.h:
+ * gtk/gtkframe.c: GtkType and macro corrections.
+
+ * gtk/gtkradiobutton.c (gtk_radio_button_set_arg): new function to
+ support radio grouping.
+
+Tue Jun 23 08:01:09 1998 Tim Janik <timj@gtk.org>
+
+ * gtk/gtkcontainer.c (gtk_container_set_resize_mode): queue a resize
+ unconditionally if resize_mode has changed.
+
+ * gtk/gtkscrolledwindow.c (gtk_scrolled_window_init): set
+ GTK_RESIZE_QUEUE on the scrolled window.
+ (gtk_scrolled_window_construct): set GTK_RESIZE_PARENT for the vieport.
+
+Tue Jun 23 04:20:30 1998 Tim Janik <timj@gtk.org>
+
+ * gtk/gtkcontainer.h:
+ * gtk/gtkcontainer.c:
+ (GTK_IS_RESIZE_CONTAINER): new macro to find out if
+ a given gtkobject is a container with resize_mode==GTK_RESIZE_PARENT.
+ (gtk_container_queue_resize): new function to queue a container for
+ a *size* reallocation (doesn't affect its position, and thus its
+ parent is left untouched usually).
+ (gtk_container_get_resize_container): new function to retrive the next
+ most resize container which is not itself queued for a resize.
+ (gtk_container_idle_sizer): new function to carefully process the
+ container_resize_queue since it can change during invokation of
+ gtk_container_check_resize().
+ (gtk_container_resize_children): total rework of this function to
+ properly handle resize containers. makes a lot of assumptions whitch
+ are stated in the comments.
+
+ * gtk/gtkcontainer.c:
+ (gtk_container_real_check_resize): only requeue ourselves if we are not
+ a resize container.
+ (gtk_container_clear_resize_widgets): care for automatic deletion of our
+ resize_widgets list on size_allocate through a handler connection.
+
+ * gtk/gtkwindow.c (gtk_window_shutdown): new functionm to reset the
+ focus and default widget of a window, so to take the burden from
+ gtk_widget_unparent.
+
+ * gtk/gtkviewport.c: removed gtk_viewport_check_resize, which tried
+ to be clever, but actually messed up the resize_children logic and
+ caused unneccessary allocations on its whole branch. besides this,
+ it messed up the display by not invoking a redraw after the allocation.
+
+ * gtk/gtktable.c (gtk_table_set_child_arg): reverted recent change, so
+ that it is the child again that is queued for a resize.
+ (gtk_table_attach): likewise.
+ (gtk_table_remove): likewise.
+
1998-06-22 Miguel de Icaza <miguel@nuclecu.unam.mx>
* gtk/gtkentry.h, gtk/gtkentry.c: Export the
* gtk-boxed.defs: s/GkWidget/GtkWidget/
+Wed Jun 24 07:47:29 1998 Tim Janik <timj@gtk.org>
+
+ * gtk/testgtk.c (create_idle_test): added a frame with radio buttons
+ to select the resize_mode for the idle-labels container.
+
+ * gtk/gtkframe.h:
+ * gtk/gtkframe.c: GtkType and macro corrections.
+
+ * gtk/gtkradiobutton.c (gtk_radio_button_set_arg): new function to
+ support radio grouping.
+
+Tue Jun 23 08:01:09 1998 Tim Janik <timj@gtk.org>
+
+ * gtk/gtkcontainer.c (gtk_container_set_resize_mode): queue a resize
+ unconditionally if resize_mode has changed.
+
+ * gtk/gtkscrolledwindow.c (gtk_scrolled_window_init): set
+ GTK_RESIZE_QUEUE on the scrolled window.
+ (gtk_scrolled_window_construct): set GTK_RESIZE_PARENT for the vieport.
+
+Tue Jun 23 04:20:30 1998 Tim Janik <timj@gtk.org>
+
+ * gtk/gtkcontainer.h:
+ * gtk/gtkcontainer.c:
+ (GTK_IS_RESIZE_CONTAINER): new macro to find out if
+ a given gtkobject is a container with resize_mode==GTK_RESIZE_PARENT.
+ (gtk_container_queue_resize): new function to queue a container for
+ a *size* reallocation (doesn't affect its position, and thus its
+ parent is left untouched usually).
+ (gtk_container_get_resize_container): new function to retrive the next
+ most resize container which is not itself queued for a resize.
+ (gtk_container_idle_sizer): new function to carefully process the
+ container_resize_queue since it can change during invokation of
+ gtk_container_check_resize().
+ (gtk_container_resize_children): total rework of this function to
+ properly handle resize containers. makes a lot of assumptions whitch
+ are stated in the comments.
+
+ * gtk/gtkcontainer.c:
+ (gtk_container_real_check_resize): only requeue ourselves if we are not
+ a resize container.
+ (gtk_container_clear_resize_widgets): care for automatic deletion of our
+ resize_widgets list on size_allocate through a handler connection.
+
+ * gtk/gtkwindow.c (gtk_window_shutdown): new functionm to reset the
+ focus and default widget of a window, so to take the burden from
+ gtk_widget_unparent.
+
+ * gtk/gtkviewport.c: removed gtk_viewport_check_resize, which tried
+ to be clever, but actually messed up the resize_children logic and
+ caused unneccessary allocations on its whole branch. besides this,
+ it messed up the display by not invoking a redraw after the allocation.
+
+ * gtk/gtktable.c (gtk_table_set_child_arg): reverted recent change, so
+ that it is the child again that is queued for a resize.
+ (gtk_table_attach): likewise.
+ (gtk_table_remove): likewise.
+
1998-06-22 Miguel de Icaza <miguel@nuclecu.unam.mx>
* gtk/gtkentry.h, gtk/gtkentry.c: Export the
(define-enum GtkCTreeLineStyle
(solid GTK_CTREE_LINES_SOLID)
(dotted GTK_CTREE_LINES_DOTTED)
+ (tabbed GTK_CTREE_LINES_TABBED)
(none GTK_CTREE_LINES_NONE))
; enumerations from "./gtkdebug.h"
(always GTK_UPDATE_ALWAYS)
(if-valid GTK_UPDATE_IF_VALID))
+(define-enum GtkSpinType
+ (step-forward GTK_SPIN_STEP_FORWARD)
+ (step-backward GTK_SPIN_STEP_BACKWARD)
+ (page-forward GTK_SPIN_PAGE_FORWARD)
+ (page-backward GTK_SPIN_PAGE_BACKWARD)
+ (home GTK_SPIN_HOME)
+ (end GTK_SPIN_END)
+ (user-defined GTK_SPIN_USER_DEFINED))
+
; enumerations from "./gtktoolbar.h"
(define-enum GtkToolbarChildType
child_info->pack = GTK_PACK_START;
if (GTK_WIDGET_VISIBLE (child) && GTK_WIDGET_VISIBLE (box))
- gtk_widget_queue_resize (GTK_WIDGET (box));
+ gtk_widget_queue_resize (child);
}
}
#include "gtkcontainer.h"
#include "gtkprivate.h"
#include "gtksignal.h"
+#include "gtkmain.h"
#include <stdarg.h>
static guint vadjustment_key_id = 0;
static const gchar *hadjustment_key = "gtk-hadjustment";
static guint hadjustment_key_id = 0;
+static GSList *container_resize_queue = NULL;
GtkType
gtk_container_get_type (void)
container = GTK_CONTAINER (object);
+ if (GTK_CONTAINER_RESIZE_PENDING (container))
+ {
+ container_resize_queue = g_slist_remove (container_resize_queue, container);
+ GTK_PRIVATE_UNSET_FLAG (container, GTK_RESIZE_PENDING);
+ }
gtk_container_clear_resize_widgets (container);
gtk_container_foreach (container,
node = container->resize_widgets;
+ if (node)
+ gtk_signal_disconnect_by_func (GTK_OBJECT (container),
+ GTK_SIGNAL_FUNC (gtk_container_clear_resize_widgets),
+ NULL);
+
while (node)
{
GtkWidget *widget = node->data;
{
container->resize_mode = resize_mode;
- if (container->resize_widgets != NULL)
+ if (resize_mode == GTK_RESIZE_IMMEDIATE)
+ gtk_container_check_resize (container);
+ else
{
- if (resize_mode == GTK_RESIZE_IMMEDIATE)
- gtk_container_check_resize (container);
- else if (resize_mode == GTK_RESIZE_PARENT)
+ gtk_container_clear_resize_widgets (container);
+ gtk_widget_queue_resize (GTK_WIDGET (container));
+ }
+ }
+}
+
+gint
+gtk_container_need_resize (GtkContainer *container)
+{
+ gtk_container_check_resize (container);
+ return FALSE;
+}
+
+static GtkContainer*
+gtk_container_get_resize_container (GtkContainer *container)
+{
+ GtkWidget *widget;
+
+ widget = GTK_WIDGET (container);
+
+ while (widget->parent)
+ {
+ widget = widget->parent;
+ if (GTK_IS_RESIZE_CONTAINER (widget) && !GTK_WIDGET_RESIZE_NEEDED (widget))
+ break;
+ }
+
+ return GTK_IS_RESIZE_CONTAINER (widget) ? (GtkContainer*) widget : NULL;
+}
+
+static gboolean
+gtk_container_idle_sizer (gpointer data)
+{
+ /* we may be invoked with a container_resize_queue of NULL, because
+ * queue_resize could have been adding an extra idle function while
+ * the queue still got processed. we better just ignore such case
+ * than trying to explicitely work around them with some extra flags,
+ * sine it doesn't cause any actual harm.
+ */
+ while (container_resize_queue)
+ {
+ GSList *slist;
+ GtkWidget *widget;
+
+ slist = container_resize_queue;
+ container_resize_queue = slist->next;
+ widget = slist->data;
+ g_slist_free_1 (slist);
+
+ GTK_PRIVATE_UNSET_FLAG (widget, GTK_RESIZE_PENDING);
+ gtk_container_check_resize (GTK_CONTAINER (widget));
+ }
+
+ return FALSE;
+}
+
+void
+gtk_container_queue_resize (GtkContainer *container)
+{
+ GtkContainer *resize_container;
+
+ g_return_if_fail (container != NULL);
+ g_return_if_fail (GTK_IS_CONTAINER (container));
+
+ if (GTK_OBJECT_DESTROYED (container) ||
+ GTK_WIDGET_RESIZE_NEEDED (container))
+ return;
+
+ if (GTK_IS_RESIZE_CONTAINER (container))
+ gtk_container_clear_resize_widgets (container);
+
+ resize_container = gtk_container_get_resize_container (container);
+
+ if (resize_container)
+ {
+ if (GTK_WIDGET_VISIBLE (resize_container))
+ {
+ switch (resize_container->resize_mode)
{
- gtk_container_clear_resize_widgets (container);
- gtk_widget_queue_resize (GTK_WIDGET (container));
+ case GTK_RESIZE_QUEUE:
+ if (!GTK_CONTAINER_RESIZE_PENDING (resize_container))
+ {
+ GTK_PRIVATE_SET_FLAG (resize_container, GTK_RESIZE_PENDING);
+ if (container_resize_queue == NULL)
+ gtk_idle_add_priority (GTK_PRIORITY_INTERNAL - 1,
+ gtk_container_idle_sizer,
+ NULL);
+ container_resize_queue = g_slist_prepend (container_resize_queue, resize_container);
+ }
+
+ GTK_PRIVATE_SET_FLAG (container, GTK_RESIZE_NEEDED);
+ if (!resize_container->resize_widgets)
+ gtk_signal_connect (GTK_OBJECT (resize_container),
+ "size_allocate",
+ GTK_SIGNAL_FUNC (gtk_container_clear_resize_widgets),
+ NULL);
+ resize_container->resize_widgets =
+ g_slist_prepend (resize_container->resize_widgets, container);
+ break;
+
+ case GTK_RESIZE_IMMEDIATE:
+ GTK_PRIVATE_SET_FLAG (container, GTK_RESIZE_NEEDED);
+ if (!resize_container->resize_widgets)
+ gtk_signal_connect (GTK_OBJECT (resize_container),
+ "size_allocate",
+ GTK_SIGNAL_FUNC (gtk_container_clear_resize_widgets),
+ NULL);
+ resize_container->resize_widgets =
+ g_slist_prepend (resize_container->resize_widgets, container);
+ gtk_container_check_resize (resize_container);
+ break;
+
+ case GTK_RESIZE_PARENT:
+ /* Ignore */
+ break;
}
}
+ else
+ {
+ /* We need to let hidden toplevels know that something
+ * changed while they where hidden. For other resize containers,
+ * they will get resized when they are shown.
+ */
+ if (GTK_WIDGET_TOPLEVEL (resize_container))
+ gtk_container_check_resize (resize_container);
+ }
}
}
gtk_signal_emit (GTK_OBJECT (container), container_signals[CHECK_RESIZE]);
}
-gint
-gtk_container_need_resize (GtkContainer *container)
-{
- gtk_container_check_resize (container);
- return FALSE;
-}
-
static void
gtk_container_real_check_resize (GtkContainer *container)
{
GtkWidget *widget;
-
+
g_return_if_fail (container != NULL);
g_return_if_fail (GTK_IS_CONTAINER (container));
-
+
widget = GTK_WIDGET (container);
-
+
gtk_widget_size_request (widget, &widget->requisition);
- if ((widget->requisition.width > widget->allocation.width) ||
- (widget->requisition.height > widget->allocation.height))
+ if (widget->requisition.width > widget->allocation.width ||
+ widget->requisition.height > widget->allocation.height)
{
- gtk_container_clear_resize_widgets (container);
- gtk_widget_queue_resize (widget);
+ if (GTK_IS_RESIZE_CONTAINER (container))
+ {
+ gtk_widget_size_allocate (GTK_WIDGET (container),
+ >K_WIDGET (container)->allocation);
+ gtk_widget_queue_draw (GTK_WIDGET (container));
+ }
+ else
+ gtk_widget_queue_resize (widget);
}
else
{
gtk_container_resize_children (GtkContainer *container)
{
GtkWidget *widget;
+ GtkWidget *resize_container;
GSList *resize_widgets;
GSList *resize_containers;
GSList *node;
+ /* resizing invariants:
+ * toplevels have *always* resize_mode != GTK_RESIZE_PARENT set.
+ * containers with resize_mode==GTK_RESIZE_PARENT have to have resize_widgets
+ * set to NULL.
+ * containers that are flagged RESIZE_NEEDED must have resize_widgets set to
+ * NULL, or are toplevels (thus have ->parent set to NULL).
+ * widgets that are in some container->resize_widgets list must be flagged with
+ * RESIZE_NEEDED.
+ * widgets that have RESIZE_NEEDED set must be referenced in some
+ * GTK_IS_RESIZE_CONTAINER (container)->resize_widgets list.
+ * containers that have an idle sizer pending must be flagged with
+ * RESIZE_PENDING.
+ */
+
g_return_if_fail (container != NULL);
g_return_if_fail (GTK_IS_CONTAINER (container));
+ /* we first check out if we actually need to perform a resize,
+ * which is not the case if we got another container queued for
+ * a resize in our anchestry. also we can skip the whole
+ * resize_widgets checks if we are a toplevel and NEED_RESIZE.
+ * this code implies that our allocation is sufficient for our
+ * requisition, since otherwise we would NEED_RESIZE.
+ */
+ resize_container = GTK_WIDGET (container);
+ while (resize_container)
+ {
+ if (GTK_WIDGET_RESIZE_NEEDED (resize_container))
+ break;
+ resize_container = resize_container->parent;
+ }
+ if (resize_container)
+ {
+ /* queue_resize and size_allocate both clear our
+ * resize_widgets list.
+ */
+ if (resize_container->parent)
+ gtk_container_queue_resize (container);
+ else
+ {
+ gtk_widget_size_allocate (GTK_WIDGET (container),
+ >K_WIDGET (container)->allocation);
+ gtk_widget_queue_draw (GTK_WIDGET (container));
+ }
+ return;
+ }
+
+ resize_container = GTK_WIDGET (container);
+
+ /* we now walk the anchestry for all resize widgets as long
+ * as they are our children and as long as their allocation
+ * is insufficient, since we don't need to reallocate below that.
+ */
resize_widgets = container->resize_widgets;
+ if (resize_widgets)
+ gtk_signal_disconnect_by_func (GTK_OBJECT (container),
+ GTK_SIGNAL_FUNC (gtk_container_clear_resize_widgets),
+ NULL);
container->resize_widgets = NULL;
-
for (node = resize_widgets; node; node = node->next)
{
widget = node->data;
-
+
GTK_PRIVATE_UNSET_FLAG (widget, GTK_RESIZE_NEEDED);
-
- while (widget && widget->parent &&
+
+ while (widget->parent != resize_container &&
((widget->allocation.width < widget->requisition.width) ||
(widget->allocation.height < widget->requisition.height)))
widget = widget->parent;
GTK_PRIVATE_SET_FLAG (widget, GTK_RESIZE_NEEDED);
node->data = widget;
}
-
+
+ /* for the newly setup resize_widgets list, we now walk each widget's
+ * anchestry to sort those widgets out that have RESIZE_NEEDED parents.
+ * we can safely stop the walk if we are the parent, since we checked
+ * our own anchestry already.
+ */
resize_containers = NULL;
-
for (node = resize_widgets; node; node = node->next)
{
- GtkWidget *resize_container;
-
+ GtkWidget *parent;
+
widget = node->data;
if (!GTK_WIDGET_RESIZE_NEEDED (widget))
continue;
- resize_container = widget->parent;
+ parent = widget->parent;
- if (resize_container)
+ while (parent != resize_container)
{
- GTK_PRIVATE_UNSET_FLAG (widget, GTK_RESIZE_NEEDED);
- widget = resize_container->parent;
-
- while (widget)
+ if (GTK_WIDGET_RESIZE_NEEDED (parent))
{
- if (GTK_WIDGET_RESIZE_NEEDED (widget))
- {
- GTK_PRIVATE_UNSET_FLAG (resize_container, GTK_RESIZE_NEEDED);
- resize_container = widget;
- }
- widget = widget->parent;
+ GTK_PRIVATE_UNSET_FLAG (widget, GTK_RESIZE_NEEDED);
+ widget = parent;
}
+ parent = parent->parent;
}
- else
- resize_container = widget;
- if (!g_slist_find (resize_containers, resize_container))
- resize_containers = g_slist_prepend (resize_containers,
- resize_container);
+ if (!g_slist_find (resize_containers, widget))
+ {
+ resize_containers = g_slist_prepend (resize_containers, widget);
+ gtk_widget_ref (widget);
+ }
}
g_slist_free (resize_widgets);
GTK_PRIVATE_UNSET_FLAG (widget, GTK_RESIZE_NEEDED);
gtk_widget_size_allocate (widget, &widget->allocation);
gtk_widget_queue_draw (widget);
+ gtk_widget_unref (widget);
}
g_slist_free (resize_containers);
}
#endif /* __cplusplus */
-#define GTK_TYPE_CONTAINER (gtk_container_get_type ())
-#define GTK_CONTAINER(obj) (GTK_CHECK_CAST ((obj), GTK_TYPE_CONTAINER, GtkContainer))
-#define GTK_CONTAINER_CLASS(klass) (GTK_CHECK_CLASS_CAST ((klass), GTK_TYPE_CONTAINER, GtkContainerClass))
-#define GTK_IS_CONTAINER(obj) (GTK_CHECK_TYPE ((obj), GTK_TYPE_CONTAINER))
-#define GTK_IS_CONTAINER_CLASS(klass) (GTK_CHECK_CLASS_TYPE ((klass), GTK_TYPE_CONTAINER))
+#define GTK_TYPE_CONTAINER (gtk_container_get_type ())
+#define GTK_CONTAINER(obj) (GTK_CHECK_CAST ((obj), GTK_TYPE_CONTAINER, GtkContainer))
+#define GTK_CONTAINER_CLASS(klass) (GTK_CHECK_CLASS_CAST ((klass), GTK_TYPE_CONTAINER, GtkContainerClass))
+#define GTK_IS_CONTAINER(obj) (GTK_CHECK_TYPE ((obj), GTK_TYPE_CONTAINER))
+#define GTK_IS_CONTAINER_CLASS(klass) (GTK_CHECK_CLASS_TYPE ((klass), GTK_TYPE_CONTAINER))
+
+#define GTK_IS_RESIZE_CONTAINER(widget) (GTK_IS_CONTAINER (widget) && ((GtkContainer*) (widget))->resize_mode != GTK_RESIZE_PARENT)
typedef struct _GtkContainer GtkContainer;
/* Non-public methods */
+void gtk_container_queue_resize (GtkContainer *container);
void gtk_container_clear_resize_widgets (GtkContainer *container);
-
+
/* Deprecated methods */
/* completely non-functional */
static GtkBinClass *parent_class = NULL;
-guint
+GtkType
gtk_frame_get_type (void)
{
- static guint frame_type = 0;
+ static GtkType frame_type = 0;
if (!frame_type)
{
#ifdef __cplusplus
extern "C" {
+#pragma }
#endif /* __cplusplus */
-#define GTK_FRAME(obj) GTK_CHECK_CAST (obj, gtk_frame_get_type (), GtkFrame)
-#define GTK_FRAME_CLASS(klass) GTK_CHECK_CLASS_CAST (klass, gtk_frame_get_type (), GtkFrameClass)
-#define GTK_IS_FRAME(obj) GTK_CHECK_TYPE (obj, gtk_frame_get_type ())
+#define GTK_TYPE_FRAME (gtk_frame_get_type ())
+#define GTK_FRAME(obj) (GTK_CHECK_CAST ((obj), GTK_TYPE_FRAME, GtkFrame))
+#define GTK_FRAME_CLASS(klass) (GTK_CHECK_CLASS_CAST ((klass), GTK_TYPE_FRAME, GtkFrameClass))
+#define GTK_IS_FRAME(obj) (GTK_CHECK_TYPE ((obj), GTK_TYPE_FRAME))
+#define GTK_IS_FRAME_CLASS(klass) (GTK_CHECK_CLASS_TYPE ((klass), GTK_TYPE_FRAME))
typedef struct _GtkFrame GtkFrame;
struct _GtkFrame
{
GtkBin bin;
-
+
gchar *label;
gint16 shadow_type;
gint16 label_width;
};
-guint gtk_frame_get_type (void);
+GtkType gtk_frame_get_type (void);
GtkWidget* gtk_frame_new (const gchar *label);
void gtk_frame_set_label (GtkFrame *frame,
const gchar *label);
#include "gtksignal.h"
+enum {
+ ARG_0,
+ ARG_GROUP
+};
+
#define CHECK_BUTTON_CLASS(w) GTK_CHECK_BUTTON_CLASS (GTK_OBJECT (w)->klass)
static void gtk_radio_button_clicked (GtkButton *button);
static void gtk_radio_button_draw_indicator (GtkCheckButton *check_button,
GdkRectangle *area);
+static void gtk_radio_button_set_arg (GtkRadioButton *radio_button,
+ GtkArg *arg,
+ guint arg_id);
+static void gtk_radio_button_get_arg (GtkRadioButton *radio_button,
+ GtkArg *arg,
+ guint arg_id);
static GtkCheckButtonClass *parent_class = NULL;
sizeof (GtkRadioButtonClass),
(GtkClassInitFunc) gtk_radio_button_class_init,
(GtkObjectInitFunc) gtk_radio_button_init,
- (GtkArgSetFunc) NULL,
- (GtkArgGetFunc) NULL,
+ (GtkArgSetFunc) gtk_radio_button_set_arg,
+ (GtkArgGetFunc) gtk_radio_button_get_arg,
};
radio_button_type = gtk_type_unique (gtk_check_button_get_type (), &radio_button_info);
parent_class = gtk_type_class (gtk_check_button_get_type ());
+ gtk_object_add_arg_type ("GtkRadioButton::group", GTK_TYPE_RADIO_BUTTON, GTK_ARG_WRITABLE, ARG_GROUP);
+
object_class->destroy = gtk_radio_button_destroy;
button_class->clicked = gtk_radio_button_clicked;
radio_button->group = g_slist_prepend (NULL, radio_button);
}
+static void
+gtk_radio_button_set_arg (GtkRadioButton *radio_button,
+ GtkArg *arg,
+ guint arg_id)
+{
+ switch (arg_id)
+ {
+ GSList *slist;
+
+ case ARG_GROUP:
+ if (GTK_VALUE_OBJECT (*arg))
+ slist = gtk_radio_button_group ((GtkRadioButton*) GTK_VALUE_OBJECT (*arg));
+ else
+ slist = NULL;
+ gtk_radio_button_set_group (radio_button, slist);
+ break;
+ default:
+ break;
+ }
+}
+
+static void
+gtk_radio_button_get_arg (GtkRadioButton *radio_button,
+ GtkArg *arg,
+ guint arg_id)
+{
+ switch (arg_id)
+ {
+ default:
+ arg->type = GTK_TYPE_INVALID;
+ break;
+ }
+}
+
void
gtk_radio_button_set_group (GtkRadioButton *radio_button,
GSList *group)
{
GTK_WIDGET_SET_FLAGS (scrolled_window, GTK_NO_WINDOW);
+ gtk_container_set_resize_mode (GTK_CONTAINER (scrolled_window), GTK_RESIZE_QUEUE);
+
scrolled_window->hscrollbar = NULL;
scrolled_window->vscrollbar = NULL;
scrolled_window->hscrollbar_policy = GTK_POLICY_ALWAYS;
scrolled_window->viewport = gtk_viewport_new (hadjustment, vadjustment);
hadjustment = gtk_viewport_get_hadjustment (GTK_VIEWPORT (scrolled_window->viewport));
vadjustment = gtk_viewport_get_vadjustment (GTK_VIEWPORT (scrolled_window->viewport));
+ gtk_container_set_resize_mode (GTK_CONTAINER (scrolled_window->viewport), GTK_RESIZE_PARENT);
gtk_signal_connect (GTK_OBJECT (hadjustment), "changed",
(GtkSignalFunc) gtk_scrolled_window_adjustment_changed,
break;
}
if (GTK_WIDGET_VISIBLE (child) && GTK_WIDGET_VISIBLE (table))
- gtk_widget_queue_resize (GTK_WIDGET (table));
+ gtk_widget_queue_resize (child);
}
static void
}
if (GTK_WIDGET_VISIBLE (child) && GTK_WIDGET_VISIBLE (table))
- gtk_widget_queue_resize (GTK_WIDGET (table));
+ gtk_widget_queue_resize (child);
}
void
g_free (child);
if (was_visible && GTK_WIDGET_VISIBLE (container))
- gtk_widget_queue_resize (GTK_WIDGET (container));
+ gtk_container_queue_resize (container);
break;
}
}
extern GtkType GTK_TYPE_ANCHOR_TYPE;
extern GtkType GTK_TYPE_PRIVATE_FLAGS;
extern GtkType GTK_TYPE_SPIN_BUTTON_UPDATE_POLICY;
+extern GtkType GTK_TYPE_SPIN_TYPE;
extern GtkType GTK_TYPE_TOOLBAR_CHILD_TYPE;
extern GtkType GTK_TYPE_TREE_VIEW_MODE;
extern GtkType GTK_TYPE_FUNDAMENTAL_TYPE;
extern GtkType GTK_TYPE_GDK_EVENT;
extern GtkType GTK_TYPE_GDK_COLOR;
-#define GTK_TYPE_NUM_BUILTINS (99)
+#define GTK_TYPE_NUM_BUILTINS (100)
static GtkEnumValue _gtk_c_tree_line_style_values[] = {
{ GTK_CTREE_LINES_SOLID, "GTK_CTREE_LINES_SOLID", "solid" },
{ GTK_CTREE_LINES_DOTTED, "GTK_CTREE_LINES_DOTTED", "dotted" },
+ { GTK_CTREE_LINES_TABBED, "GTK_CTREE_LINES_TABBED", "tabbed" },
{ GTK_CTREE_LINES_NONE, "GTK_CTREE_LINES_NONE", "none" },
{ 0, NULL, NULL }
};
{ GTK_UPDATE_IF_VALID, "GTK_UPDATE_IF_VALID", "if-valid" },
{ 0, NULL, NULL }
};
+static GtkEnumValue _gtk_spin_type_values[] = {
+ { GTK_SPIN_STEP_FORWARD, "GTK_SPIN_STEP_FORWARD", "step-forward" },
+ { GTK_SPIN_STEP_BACKWARD, "GTK_SPIN_STEP_BACKWARD", "step-backward" },
+ { GTK_SPIN_PAGE_FORWARD, "GTK_SPIN_PAGE_FORWARD", "page-forward" },
+ { GTK_SPIN_PAGE_BACKWARD, "GTK_SPIN_PAGE_BACKWARD", "page-backward" },
+ { GTK_SPIN_HOME, "GTK_SPIN_HOME", "home" },
+ { GTK_SPIN_END, "GTK_SPIN_END", "end" },
+ { GTK_SPIN_USER_DEFINED, "GTK_SPIN_USER_DEFINED", "user-defined" },
+ { 0, NULL, NULL }
+};
static GtkEnumValue _gtk_toolbar_child_type_values[] = {
{ GTK_TOOLBAR_CHILD_SPACE, "GTK_TOOLBAR_CHILD_SPACE", "space" },
{ GTK_TOOLBAR_CHILD_BUTTON, "GTK_TOOLBAR_CHILD_BUTTON", "button" },
GTK_TYPE_FLAGS, _gtk_private_flags_values },
{ "GtkSpinButtonUpdatePolicy", >K_TYPE_SPIN_BUTTON_UPDATE_POLICY,
GTK_TYPE_ENUM, _gtk_spin_button_update_policy_values },
+ { "GtkSpinType", >K_TYPE_SPIN_TYPE,
+ GTK_TYPE_ENUM, _gtk_spin_type_values },
{ "GtkToolbarChildType", >K_TYPE_TOOLBAR_CHILD_TYPE,
GTK_TYPE_ENUM, _gtk_toolbar_child_type_values },
{ "GtkTreeViewMode", >K_TYPE_TREE_VIEW_MODE,
GtkType GTK_TYPE_ANCHOR_TYPE = 0;
GtkType GTK_TYPE_PRIVATE_FLAGS = 0;
GtkType GTK_TYPE_SPIN_BUTTON_UPDATE_POLICY = 0;
+GtkType GTK_TYPE_SPIN_TYPE = 0;
GtkType GTK_TYPE_TOOLBAR_CHILD_TYPE = 0;
GtkType GTK_TYPE_TREE_VIEW_MODE = 0;
GtkType GTK_TYPE_FUNDAMENTAL_TYPE = 0;
GtkRequisition *requisition);
static void gtk_viewport_size_allocate (GtkWidget *widget,
GtkAllocation *allocation);
-static void gtk_viewport_check_resize (GtkContainer *container);
static void gtk_viewport_adjustment_changed (GtkAdjustment *adjustment,
gpointer data);
static void gtk_viewport_adjustment_value_changed (GtkAdjustment *adjustment,
widget_class->size_allocate = gtk_viewport_size_allocate;
container_class->add = gtk_viewport_add;
- container_class->check_resize = gtk_viewport_check_resize;
}
static void
}
}
-static void
-gtk_viewport_check_resize (GtkContainer *container)
-{
- GtkBin *bin;
-
- g_return_if_fail (container != NULL);
- g_return_if_fail (GTK_IS_VIEWPORT (container));
-
- if (GTK_WIDGET_REALIZED (container))
- {
- bin = GTK_BIN (container);
-
- gtk_widget_size_request (bin->child, &bin->child->requisition);
-
- gtk_widget_size_allocate (GTK_WIDGET (container),
- &(GTK_WIDGET (container)->allocation));
- }
-}
-
static void
gtk_viewport_adjustment_changed (GtkAdjustment *adjustment,
gpointer data)
static GdkVisual* gtk_widget_peek_visual (void);
static GtkStyle* gtk_widget_peek_style (void);
-static GtkWidget* gtk_widget_get_resize_container (GtkWidget *widget);
static void gtk_widget_reparent_container_child (GtkWidget *widget,
gpointer client_data);
static void gtk_widget_propagate_state (GtkWidget *widget,
static GSList *style_stack = NULL;
static GSList *gtk_widget_redraw_queue = NULL;
-static GSList *gtk_widget_resize_queue = NULL;
static const gchar *aux_info_key = "gtk-aux-info";
static guint aux_info_key_id = 0;
{
GtkWidget *toplevel;
GtkWidget *old_parent;
- GSList *tmp_list, *prev_list;
g_return_if_fail (widget != NULL);
if (widget->parent == NULL)
/* keep this function in sync with gtk_menu_detach()
*/
- /* unset focused and default children properly
+ /* unset focused and default children properly, this code
+ * should eventually move into some gtk_window_unparent_branch() or
+ * similar function.
*/
toplevel = gtk_widget_get_toplevel (widget);
if (GTK_CONTAINER (widget->parent)->focus_child == widget)
gtk_window_set_default (GTK_WINDOW (toplevel), NULL);
}
- /* Remove the widget and all its children from toplevel->resize_widgets
- */
-
-
- toplevel = gtk_widget_get_resize_container (widget);
-
- /* Three ways to make this prettier:
+ if (GTK_IS_RESIZE_CONTAINER (widget))
+ gtk_container_clear_resize_widgets (GTK_CONTAINER (widget));
+
+ /* Remove the widget and all its children from any ->resize_widgets list
+ * of all the parents in our branch. This code should move into gtkcontainer.c
+ * somwhen, since we mess around with ->resize_widgets, which is
+ * actually not of our business.
+ *
+ * Two ways to make this prettier:
* Write a g_slist_conditional_remove (GSList, gboolean (*)(gpointer))
* Change resize_widgets to a GList
- * Just bite the bullet and use g_slist_remove
*/
-
- tmp_list = GTK_CONTAINER (toplevel)->resize_widgets;
- prev_list = NULL;
- while (tmp_list)
+ toplevel = widget->parent;
+ while (toplevel)
{
- GSList *tmp = tmp_list;
- GtkWidget *child = (GtkWidget *)tmp->data;
- GtkWidget *parent = child;
+ GSList *slist;
+ GSList *prev;
- tmp_list = tmp_list->next;
-
- while (parent && (parent != widget))
- parent = parent->parent;
+ if (!GTK_CONTAINER (toplevel)->resize_widgets)
+ {
+ toplevel = toplevel->parent;
+ continue;
+ }
- if (parent == widget)
+ prev = NULL;
+ slist = GTK_CONTAINER (toplevel)->resize_widgets;
+ while (slist)
{
- GTK_PRIVATE_UNSET_FLAG (child, GTK_RESIZE_NEEDED);
+ GtkWidget *child;
+ GtkWidget *parent;
+ GSList *last;
- if (prev_list)
- prev_list->next = tmp_list;
+ last = slist;
+ slist = last->next;
+ child = last->data;
+
+ parent = child;
+ while (parent && (parent != widget))
+ parent = parent->parent;
+
+ if (parent == widget)
+ {
+ GTK_PRIVATE_UNSET_FLAG (child, GTK_RESIZE_NEEDED);
+
+ if (prev)
+ prev->next = slist;
+ else
+ {
+ /* it is really messy to have this signal disconnection
+ * in gtkwidget.c, the resize_widgets invariants should
+ * all be taken care off by gtkcontainer.c exclusively.
+ */
+ if (!slist)
+ gtk_signal_disconnect_by_func (GTK_OBJECT (toplevel),
+ GTK_SIGNAL_FUNC (gtk_container_clear_resize_widgets),
+ NULL);
+ GTK_CONTAINER (toplevel)->resize_widgets = slist;
+ }
+
+ g_slist_free_1 (last);
+ }
else
- GTK_CONTAINER (toplevel)->resize_widgets = tmp_list;
-
- tmp->next = NULL;
-
- g_slist_free_1 (tmp);
+ prev = last;
}
- else
- prev_list = tmp;
+
+ toplevel = toplevel->parent;
}
if (widget->window &&
g_return_if_fail (widget != NULL);
g_assert (widget->parent);
- if (GTK_WIDGET_RESIZE_NEEDED (widget))
- {
- GtkWidget *toplevel;
-
- toplevel = gtk_widget_get_resize_container (widget);
- GTK_CONTAINER (toplevel)->resize_widgets =
- g_slist_remove (GTK_CONTAINER (toplevel)->resize_widgets, widget);
- GTK_PRIVATE_UNSET_FLAG (widget, GTK_RESIZE_NEEDED);
- }
-
GTK_WIDGET_CLASS (GTK_OBJECT (widget)->klass)->hide_all (widget);
}
}
}
-/*****************************************
- * gtk_widget_queue_resize:
- *
- * arguments:
- *
- * results:
- *****************************************/
-
-static gint
-gtk_widget_idle_sizer (void *data)
-{
- GSList *slist = gtk_widget_resize_queue;
- GSList *node = slist;
-
- gtk_widget_resize_queue = NULL;
-
- while (node)
- {
- GtkWidget *widget = node->data;
-
- GTK_PRIVATE_UNSET_FLAG (widget, GTK_RESIZE_PENDING);
- gtk_container_check_resize (GTK_CONTAINER (widget));
-
- node = node->next;
- }
-
- g_slist_free (slist);
-
- return FALSE;
-}
-
-/* The guts here should probably be moved into gtkcontainer.c */
-
void
gtk_widget_queue_resize (GtkWidget *widget)
{
- GtkWidget *resize_widget;
- GtkContainer *container;
-
g_return_if_fail (widget != NULL);
- if (GTK_OBJECT_DESTROYED (widget))
- return;
-
- resize_widget = gtk_widget_get_resize_container (widget);
+ g_return_if_fail (GTK_IS_WIDGET (widget));
- if (resize_widget)
- {
- container = GTK_CONTAINER (resize_widget);
-
- if (GTK_WIDGET_VISIBLE (container))
- {
- switch (container->resize_mode)
- {
- case GTK_RESIZE_QUEUE:
- if (!GTK_CONTAINER_RESIZE_PENDING (container))
- {
- GTK_PRIVATE_SET_FLAG (container, GTK_RESIZE_PENDING);
- if (gtk_widget_resize_queue == NULL)
- gtk_idle_add_priority (GTK_PRIORITY_INTERNAL - 1,
- gtk_widget_idle_sizer,
- NULL);
- gtk_widget_resize_queue = g_slist_prepend (gtk_widget_resize_queue, container);
- }
-
- if (!GTK_WIDGET_RESIZE_NEEDED (widget))
- {
- GTK_PRIVATE_SET_FLAG (widget, GTK_RESIZE_NEEDED);
- container->resize_widgets =
- g_slist_prepend (container->resize_widgets, widget);
- }
- else
- g_assert (g_slist_find (container->resize_widgets, widget)); /* paranoid */
- break;
+ if (GTK_IS_RESIZE_CONTAINER (widget))
+ gtk_container_clear_resize_widgets (GTK_CONTAINER (widget));
- case GTK_RESIZE_IMMEDIATE:
- if (!GTK_WIDGET_RESIZE_NEEDED (widget))
- {
- GTK_PRIVATE_SET_FLAG (widget, GTK_RESIZE_NEEDED);
- container->resize_widgets =
- g_slist_prepend (container->resize_widgets, widget);
- gtk_container_check_resize (container);
- }
- break;
- case GTK_RESIZE_PARENT:
- /* Ignore */
- break;
- }
- }
- else
- {
- /* We need to let hidden toplevels know that something
- * changed while they where hidden. For other resize containers,
- * they will get resized when they are shown.
- */
- if (GTK_WIDGET_TOPLEVEL (container))
- gtk_container_check_resize (container);
- }
- }
+ if (widget->parent)
+ gtk_container_queue_resize (GTK_CONTAINER (widget->parent));
+ else if (GTK_WIDGET_TOPLEVEL (widget))
+ gtk_container_queue_resize (GTK_CONTAINER (widget));
}
/*****************************************
gtk_object_set_data_by_id (GTK_OBJECT (widget), extension_event_key_id, modep);
}
-
-/*****************************************
- * gtk_widget_get_resize_container:
- *
- * arguments:
- *
- * results:
- *****************************************/
-
-static GtkWidget *
-gtk_widget_get_resize_container (GtkWidget *widget)
-{
- g_return_val_if_fail (widget != NULL, NULL);
-
- while (widget->parent)
- {
- widget = widget->parent;
- if (GTK_CONTAINER (widget)->resize_mode != GTK_RESIZE_PARENT)
- break;
- }
-
- return GTK_IS_CONTAINER (widget) ? widget : NULL;
-}
-
/*****************************************
* gtk_widget_get_toplevel:
*
*/
widget = GTK_WIDGET (object);
- if (GTK_CONTAINER_RESIZE_PENDING (widget))
- {
- gtk_widget_resize_queue = g_slist_remove (gtk_widget_resize_queue, widget);
- GTK_PRIVATE_UNSET_FLAG (widget, GTK_RESIZE_PENDING);
- }
-
gtk_grab_remove (widget);
gtk_selection_remove_all (widget);
gtk_widget_unmap (widget);
if (widget->parent)
- gtk_widget_queue_resize (widget);
+ gtk_widget_queue_resize (widget->parent);
}
}
{
gdk_window_set_user_data (widget->window, NULL);
gdk_window_destroy (widget->window);
+ widget->window = NULL;
}
else
{
gdk_window_unref (widget->window);
+ widget->window = NULL;
}
/* Unrealize afterwards to improve visual effect */
if (GTK_IS_CONTAINER (widget))
gtk_container_foreach (GTK_CONTAINER (widget),
- (GtkCallback)gtk_widget_unrealize,
+ (GtkCallback) gtk_widget_unrealize,
NULL);
-
- widget->window = NULL;
}
/*****************************************
static void gtk_window_get_arg (GtkWindow *window,
GtkArg *arg,
guint arg_id);
+static void gtk_window_shutdown (GtkObject *object);
static void gtk_window_destroy (GtkObject *object);
static void gtk_window_finalize (GtkObject *object);
static void gtk_window_show (GtkWidget *widget);
gtk_object_class_add_signals (object_class, window_signals, LAST_SIGNAL);
+ object_class->shutdown = gtk_window_shutdown;
object_class->destroy = gtk_window_destroy;
object_class->finalize = gtk_window_finalize;
GTK_WIDGET_UNSET_FLAGS (window, GTK_NO_WINDOW);
GTK_WIDGET_SET_FLAGS (window, GTK_TOPLEVEL);
+ gtk_container_set_resize_mode (GTK_CONTAINER (window), GTK_RESIZE_QUEUE);
+
window->title = NULL;
window->wmclass_name = g_strdup (gdk_progname);
window->wmclass_class = g_strdup (gdk_progclass);
window->position = GTK_WIN_POS_NONE;
window->use_uposition = TRUE;
- gtk_container_set_resize_mode (GTK_CONTAINER (window), GTK_RESIZE_QUEUE);
gtk_container_register_toplevel (GTK_CONTAINER (window));
}
(* rfunc) (object, GTK_VALUE_POINTER (args[0]), func_data);
}
+static void
+gtk_window_shutdown (GtkObject *object)
+{
+ GtkWindow *window;
+
+ g_return_if_fail (object != NULL);
+ g_return_if_fail (GTK_IS_WINDOW (object));
+
+ window = GTK_WINDOW (object);
+
+ gtk_window_set_focus (window, NULL);
+ gtk_window_set_default (window, NULL);
+
+ GTK_OBJECT_CLASS (parent_class)->shutdown (object);
+}
+
static void
gtk_window_destroy (GtkObject *object)
{
gtk_container_unregister_toplevel (GTK_CONTAINER (object));
- if (GTK_OBJECT_CLASS (parent_class)->destroy)
- (* GTK_OBJECT_CLASS (parent_class)->destroy) (object);
+ GTK_OBJECT_CLASS (parent_class)->destroy (object);
}
static void
allocation.height = widget->requisition.height;
gtk_widget_size_allocate (widget, &allocation);
- gtk_container_clear_resize_widgets (GTK_CONTAINER (window));
}
else
{
*/
static int idle = 0;
-gint
+static gint
idle_test (GtkWidget *label)
{
static int count = 0;
return TRUE;
}
-void
+static void
start_idle_test (GtkWidget *widget,
GtkWidget *label)
{
}
}
-void
+static void
stop_idle_test (GtkWidget *widget,
gpointer data)
{
}
}
-void
+static void
destroy_idle_test (GtkWidget *widget,
GtkWidget **window)
{
*window = NULL;
}
-void
+static void
+toggle_idle_container (GtkObject *button,
+ GtkContainer *container)
+{
+ gtk_container_set_resize_mode (container, (guint) gtk_object_get_user_data (button));
+}
+
+static void
create_idle_test (void)
{
static GtkWidget *window = NULL;
GtkWidget *button;
GtkWidget *label;
+ GtkWidget *container;
if (!window)
{
+ GtkWidget *frame;
+ GtkWidget *box;
+
window = gtk_dialog_new ();
gtk_signal_connect (GTK_OBJECT (window), "destroy",
label = gtk_label_new ("count: 0");
gtk_misc_set_padding (GTK_MISC (label), 10, 10);
- gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->vbox),
- label, TRUE, TRUE, 0);
gtk_widget_show (label);
+
+ container =
+ gtk_widget_new (GTK_TYPE_HBOX,
+ "GtkWidget::visible", TRUE,
+ /* "GtkContainer::child", gtk_widget_new (GTK_TYPE_HBOX,
+ * "GtkWidget::visible", TRUE,
+ */
+ "GtkContainer::child", label,
+ /* NULL), */
+ NULL);
+ gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->vbox),
+ container, TRUE, TRUE, 0);
+
+ frame =
+ gtk_widget_new (GTK_TYPE_FRAME,
+ "GtkContainer::border_width", 5,
+ "GtkFrame::label", "Label Container",
+ "GtkWidget::visible", TRUE,
+ "GtkWidget::parent", GTK_DIALOG (window)->vbox,
+ NULL);
+ box =
+ gtk_widget_new (GTK_TYPE_VBOX,
+ "GtkWidget::visible", TRUE,
+ "GtkWidget::parent", frame,
+ NULL);
+ button =
+ gtk_widget_new (GTK_TYPE_RADIO_BUTTON,
+ "GtkButton::label", "Resize-Parent",
+ "GtkObject::user_data", (void*)GTK_RESIZE_PARENT,
+ "GtkObject::signal::clicked", toggle_idle_container, container,
+ "GtkWidget::visible", TRUE,
+ "GtkWidget::parent", box,
+ NULL);
+ button =
+ gtk_widget_new (GTK_TYPE_RADIO_BUTTON,
+ "GtkButton::label", "Resize-Queue",
+ "GtkObject::user_data", (void*)GTK_RESIZE_QUEUE,
+ "GtkObject::signal::clicked", toggle_idle_container, container,
+ "GtkRadioButton::group", button,
+ "GtkWidget::visible", TRUE,
+ "GtkWidget::parent", box,
+ NULL);
+ button =
+ gtk_widget_new (GTK_TYPE_RADIO_BUTTON,
+ "GtkButton::label", "Resize-Immediate",
+ "GtkObject::user_data", (void*)GTK_RESIZE_IMMEDIATE,
+ "GtkObject::signal::clicked", toggle_idle_container, container,
+ "GtkRadioButton::group", button,
+ "GtkWidget::visible", TRUE,
+ "GtkWidget::parent", box,
+ NULL);
+
button = gtk_button_new_with_label ("close");
gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
*/
static int idle = 0;
-gint
+static gint
idle_test (GtkWidget *label)
{
static int count = 0;
return TRUE;
}
-void
+static void
start_idle_test (GtkWidget *widget,
GtkWidget *label)
{
}
}
-void
+static void
stop_idle_test (GtkWidget *widget,
gpointer data)
{
}
}
-void
+static void
destroy_idle_test (GtkWidget *widget,
GtkWidget **window)
{
*window = NULL;
}
-void
+static void
+toggle_idle_container (GtkObject *button,
+ GtkContainer *container)
+{
+ gtk_container_set_resize_mode (container, (guint) gtk_object_get_user_data (button));
+}
+
+static void
create_idle_test (void)
{
static GtkWidget *window = NULL;
GtkWidget *button;
GtkWidget *label;
+ GtkWidget *container;
if (!window)
{
+ GtkWidget *frame;
+ GtkWidget *box;
+
window = gtk_dialog_new ();
gtk_signal_connect (GTK_OBJECT (window), "destroy",
label = gtk_label_new ("count: 0");
gtk_misc_set_padding (GTK_MISC (label), 10, 10);
- gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->vbox),
- label, TRUE, TRUE, 0);
gtk_widget_show (label);
+
+ container =
+ gtk_widget_new (GTK_TYPE_HBOX,
+ "GtkWidget::visible", TRUE,
+ /* "GtkContainer::child", gtk_widget_new (GTK_TYPE_HBOX,
+ * "GtkWidget::visible", TRUE,
+ */
+ "GtkContainer::child", label,
+ /* NULL), */
+ NULL);
+ gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->vbox),
+ container, TRUE, TRUE, 0);
+
+ frame =
+ gtk_widget_new (GTK_TYPE_FRAME,
+ "GtkContainer::border_width", 5,
+ "GtkFrame::label", "Label Container",
+ "GtkWidget::visible", TRUE,
+ "GtkWidget::parent", GTK_DIALOG (window)->vbox,
+ NULL);
+ box =
+ gtk_widget_new (GTK_TYPE_VBOX,
+ "GtkWidget::visible", TRUE,
+ "GtkWidget::parent", frame,
+ NULL);
+ button =
+ gtk_widget_new (GTK_TYPE_RADIO_BUTTON,
+ "GtkButton::label", "Resize-Parent",
+ "GtkObject::user_data", (void*)GTK_RESIZE_PARENT,
+ "GtkObject::signal::clicked", toggle_idle_container, container,
+ "GtkWidget::visible", TRUE,
+ "GtkWidget::parent", box,
+ NULL);
+ button =
+ gtk_widget_new (GTK_TYPE_RADIO_BUTTON,
+ "GtkButton::label", "Resize-Queue",
+ "GtkObject::user_data", (void*)GTK_RESIZE_QUEUE,
+ "GtkObject::signal::clicked", toggle_idle_container, container,
+ "GtkRadioButton::group", button,
+ "GtkWidget::visible", TRUE,
+ "GtkWidget::parent", box,
+ NULL);
+ button =
+ gtk_widget_new (GTK_TYPE_RADIO_BUTTON,
+ "GtkButton::label", "Resize-Immediate",
+ "GtkObject::user_data", (void*)GTK_RESIZE_IMMEDIATE,
+ "GtkObject::signal::clicked", toggle_idle_container, container,
+ "GtkRadioButton::group", button,
+ "GtkWidget::visible", TRUE,
+ "GtkWidget::parent", box,
+ NULL);
+
button = gtk_button_new_with_label ("close");
gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
projects / gtk4.git / commitdiff